/**
 * ZIP解压只存储的文件，使用deflate压缩的需要inflate插件
 * @author lonphy
 * @version 1.0
 */
(function(G){
	"use strict";
	
	function ZIP(data) {
		if ( ! (data instanceof ArrayBuffer) ) {
			throw "invalid param for ZIP constructor, the param data must be ArrayBuffer";
		}
		this.reader = new ZIP.Reader(data);
	}
	
	// zip flag
	ZIP.MAGIC_NUM = 0x04034b50;
	
	G.ZIP = ZIP;
	
	ZIP.prototype = {
			constroctor: ZIP,
			getEntries: function() {
				if (!this.isValid()) {
					throw "Invalid zip file";
				}
				this.entries = [];
				
				var entry = new ZIP.Entry(this.reader);
	            while (typeof(entry.data) === "string") {
	                this.entries.push(entry);
	                entry = new ZIP.Entry(this.reader);
	            }
				this.reader.free();	// GC
			},
			
			/**
			 * 获取下个节点
			 * @return {ZIP.Entry}
			 */
			getNextEntry : function(){
				return this.entries.shift() || null;
			},
			isValid: function() {
				return this.reader.getUint32(0) === ZIP.MAGIC_NUM;
			}
	};
	
	ZIP.Entry = function(reader){
		this.signature = reader.nextUint32();
		// entry header signature
		if (this.signature !== ZIP.MAGIC_NUM) return;
		this.versionNeeded		= reader.nextUint16();
		this.bitFlag 			= reader.nextUint16();
		this.compressionMethod	= reader.nextUint16();
		this.timeBlob			= reader.nextUint32();
        if (this.isEncrypted()) {
            throw "File contains encrypted entry. Not supported.";
        }

        if (this.isUsingUtf8()) {
            throw "File is using UTF8. Not supported.";
        }
        this.crc32				= reader.nextUint32();
        this.compressedSize		= reader.nextUint32();
        this.uncompressedSize	= reader.nextUint32();
        if (this.isUsingZip64()) {
            throw "File is using Zip64 (4gb+ file size). Not supported";
        }
        
        this.fileNameLength		= reader.nextUint16();
        this.extraFieldLength	= reader.nextUint16();

        this.fileName			= reader.nextAsString(this.fileNameLength);
        this.isdir				= (this.fileName.slice(-1) === '/');
        this.extra				= reader.nextAsString(this.extraFieldLength);
		if (this.compressionMethod === 8) { // inflate data
			this.data			= ZIP.plugin.inflate( reader.nextAsString(this.compressedSize) );
		} else {
			this.data			= reader.nextAsString(this.compressedSize);
		}
        
        if (this.isUsingBit3TrailingDataDescriptor()) {
        	console.log("File is using bit 3 trailing data descriptor. Not supported.");
            reader.skip(16);
        }
	};
	
	ZIP.Entry.prototype = {
			constructor: ZIP.Entry,
			isEncrypted: function() {
				 return (this.bitFlag & 0x01) === 0x01;
			},
			isUsingUtf8: function() {
				return (this.bitFlag & 0x0800) === 0x0800;
			},
	        isUsingZip64: function () {
	            this.compressedSize === 0xFFFFFFFF ||
	                this.uncompressedSize === 0xFFFFFFFF;
	        },
	        isUsingBit3TrailingDataDescriptor: function () {
	            return (this.bitFlag & 0x0008) === 0x0008;
	        }
	};
	
	ZIP.Reader = function(data){
		this.content = new DataView(data);
		
		// 8bit offset = 1byte;
		this.byteOffset = 0;
	}
	
	ZIP.Reader.prototype = {
			constructor: ZIP.Reader,
			skip: function(step) {
				this.byteOffset += step || 0;
			},
			nextUint32: function() {
				var result = this.content.getUint32(this.byteOffset, true);
				this.byteOffset += 4;
				return result;
			},
			nextUint16: function() {
				var result = this.content.getUint16(this.byteOffset, true);
				this.byteOffset += 2;
				return result;
			},
			nextUint8: function() {
				var result = this.content.getUint8(this.byteOffset);
				this.byteOffset += 1;
				return result;
			},
			
			nextAsString: function(length) {
				var result = "",
					i = this.byteOffset,
					max = i+length;
	            while ( i < max) {
	                var char = this.getUint8(i);
	                result += String.fromCharCode(char);
	                // Accounting for multi-byte strings.
	                max -= Math.floor(char / 0x100);
	                i++;
	            }
	            
	            this.byteOffset += length;
	            return result;
			},
			getUint8: function(index) {
				return this.content.getUint8(index || 0);
			},
			getUint32: function(index) {
				return this.content.getUint32(index || 0, true);
			},
			free: function() {
				delete this.content;
			}
	};
	ZIP.plugin = {};
}(this));

/**********************************************
 * inflate plugin for ZIP
 **********************************************/
(function(ZIP){
	"use strict";
	var zip_WSIZE = 0x8000,	// Sliding Window size
		zip_STORED_BLOCK = 0,
		zip_STATIC_TREES = 1,
		zip_DYN_TREES = 2,

		/* for inflate */
		zip_lbits = 9, 		// bits in base literal/length lookup table
		zip_dbits = 6, 		// bits in base distance lookup table
		zip_INBUFSIZ = 0x8000,	// Input buffer size
		zip_INBUF_EXTRA = 0x40,	// Extra buffer

		/* variables (inflate) */
		zip_slide,
		zip_wp,		// current position in slide
		zip_fixed_tl = null,	// inflate static
		zip_fixed_td,		// inflate static
		zip_fixed_bl, zip_fixed_bd,	// inflate static
		zip_bit_buf,		// bit buffer
		zip_bit_len,		// bits in bit buffer
		zip_method,
		zip_eof,
		zip_copy_leng,
		zip_copy_dist,
		zip_tl, zip_td,	// literal/length and distance decoder tables
		zip_bl, zip_bd,	// number of bits decoded by tl and td

		zip_inflate_data,
		zip_inflate_pos,


		/* constant tables (inflate) */
		zip_MASK_BITS = [
			0x0000,
			0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
			0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff],
		// Tables for deflate from PKZIP's appnote.txt.
		zip_cplens = [ // Copy lengths for literal codes 257..285
			3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
			35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0],
		/* note: see note #13 above about the 258 in this list. */
		zip_cplext = [ // Extra bits for literal codes 257..285
			0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
			3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99], // 99==invalid
		zip_cpdist = [ // Copy offsets for distance codes 0..29
			1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
			257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
			8193, 12289, 16385, 24577],
		zip_cpdext = [ // Extra bits for distance codes
        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
        12, 12, 13, 13],
		zip_border = [  // Order of the bit length code lengths
        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
    
	/* objects (inflate) */

    function zip_HuftList() {
        this.next = null;
        this.list = null;
    }

    function zip_HuftNode() {
        this.e = 0; // number of extra bits or operation
        this.b = 0; // number of bits in this code or subcode

        // union
        this.n = 0; // literal, length base, or distance base
        this.t = null; // (zip_HuftNode) pointer to next level of table
    }

    function zip_HuftBuild(b,	// code lengths in bits (all assumed <= BMAX)
                           n,	// number of codes (assumed <= N_MAX)
                           s,	// number of simple-valued codes (0..s-1)
                           d,	// list of base values for non-simple codes
                           e,	// list of extra bits for non-simple codes
                           mm	// maximum lookup bits
        ) {
        this.BMAX = 16;   // maximum bit length of any code
        this.N_MAX = 288; // maximum number of codes in any set
        this.status = 0;	// 0: success, 1: incomplete table, 2: bad input
        this.root = null;	// (zip_HuftList) starting table
        this.m = 0;		// maximum lookup bits, returns actual

        /* Given a list of code lengths and a maximum table size, make a set of
         tables to decode that set of codes.	Return zero on success, one if
         the given code set is incomplete (the tables are still built in this
         case), two if the input is invalid (all zero length codes or an
         oversubscribed set of lengths), and three if not enough memory.
         The code with value 256 is special, and the tables are constructed
         so that no bits beyond that code are fetched when that code is
         decoded. */
        {
            var a;			// counter for codes of length k
            var c = new Array(this.BMAX + 1);	// bit length count table
            var el;			// length of EOB code (value 256)
            var f;			// i repeats in table every f entries
            var g;			// maximum code length
            var h;			// table level
            var i;			// counter, current code
            var j;			// counter
            var k;			// number of bits in current code
            var lx = new Array(this.BMAX + 1);	// stack of bits per table
            var p;			// pointer into c[], b[], or v[]
            var pidx;		// index of p
            var q;			// (zip_HuftNode) points to current table
            var r = new zip_HuftNode(); // table entry for structure assignment
            var u = new Array(this.BMAX); // zip_HuftNode[BMAX][]  table stack
            var v = new Array(this.N_MAX); // values in order of bit length
            var w;
            var x = new Array(this.BMAX + 1);// bit offsets, then code stack
            var xp;			// pointer into x or c
            var y;			// number of dummy codes added
            var z;			// number of entries in current table
            var o;
            var tail;		// (zip_HuftList)

            tail = this.root = null;
            for (i = 0; i < c.length; i++)
                c[i] = 0;
            for (i = 0; i < lx.length; i++)
                lx[i] = 0;
            for (i = 0; i < u.length; i++)
                u[i] = null;
            for (i = 0; i < v.length; i++)
                v[i] = 0;
            for (i = 0; i < x.length; i++)
                x[i] = 0;

            // Generate counts for each bit length
            el = n > 256 ? b[256] : this.BMAX; // set length of EOB code, if any
            p = b;
            pidx = 0;
            i = n;
            do {
                c[p[pidx]]++;	// assume all entries <= BMAX
                pidx++;
            } while (--i > 0);
            if (c[0] == n) {	// null input--all zero length codes
                this.root = null;
                this.m = 0;
                this.status = 0;
                return;
            }

            // Find minimum and maximum length, bound *m by those
            for (j = 1; j <= this.BMAX; j++)
                if (c[j] != 0)
                    break;
            k = j;			// minimum code length
            if (mm < j)
                mm = j;
            for (i = this.BMAX; i != 0; i--)
                if (c[i] != 0)
                    break;
            g = i;			// maximum code length
            if (mm > i)
                mm = i;

            // Adjust last length count to fill out codes, if needed
            for (y = 1 << j; j < i; j++, y <<= 1)
                if ((y -= c[j]) < 0) {
                    this.status = 2;	// bad input: more codes than bits
                    this.m = mm;
                    return;
                }
            if ((y -= c[i]) < 0) {
                this.status = 2;
                this.m = mm;
                return;
            }
            c[i] += y;

            // Generate starting offsets into the value table for each length
            x[1] = j = 0;
            p = c;
            pidx = 1;
            xp = 2;
            while (--i > 0)		// note that i == g from above
                x[xp++] = (j += p[pidx++]);

            // Make a table of values in order of bit lengths
            p = b;
            pidx = 0;
            i = 0;
            do {
                if ((j = p[pidx++]) != 0)
                    v[x[j]++] = i;
            } while (++i < n);
            n = x[g];			// set n to length of v

            // Generate the Huffman codes and for each, make the table entries
            x[0] = i = 0;		// first Huffman code is zero
            p = v;
            pidx = 0;		// grab values in bit order
            h = -1;			// no tables yet--level -1
            w = lx[0] = 0;		// no bits decoded yet
            q = null;			// ditto
            z = 0;			// ditto

            // go through the bit lengths (k already is bits in shortest code)
            for (; k <= g; k++) {
                a = c[k];
                while (a-- > 0) {
                    // here i is the Huffman code of length k bits for value p[pidx]
                    // make tables up to required level
                    while (k > w + lx[1 + h]) {
                        w += lx[1 + h]; // add bits already decoded
                        h++;

                        // compute minimum size table less than or equal to *m bits
                        z = (z = g - w) > mm ? mm : z; // upper limit
                        if ((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table
                            // too few codes for k-w bit table
                            f -= a + 1;	// deduct codes from patterns left
                            xp = k;
                            while (++j < z) { // try smaller tables up to z bits
                                if ((f <<= 1) <= c[++xp])
                                    break;	// enough codes to use up j bits
                                f -= c[xp];	// else deduct codes from patterns
                            }
                        }
                        if (w + j > el && w < el)
                            j = el - w;	// make EOB code end at table
                        z = 1 << j;	// table entries for j-bit table
                        lx[1 + h] = j; // set table size in stack

                        // allocate and link in new table
                        q = new Array(z);
                        for (o = 0; o < z; o++) {
                            q[o] = new zip_HuftNode();
                        }

                        if (tail == null)
                            tail = this.root = new zip_HuftList();
                        else
                            tail = tail.next = new zip_HuftList();
                        tail.next = null;
                        tail.list = q;
                        u[h] = q;	// table starts after link

                        /* connect to last table, if there is one */
                        if (h > 0) {
                            x[h] = i;		// save pattern for backing up
                            r.b = lx[h];	// bits to dump before this table
                            r.e = 16 + j;	// bits in this table
                            r.t = q;		// pointer to this table
                            j = (i & ((1 << w) - 1)) >> (w - lx[h]);
                            u[h - 1][j].e = r.e;
                            u[h - 1][j].b = r.b;
                            u[h - 1][j].n = r.n;
                            u[h - 1][j].t = r.t;
                        }
                    }

                    // set up table entry in r
                    r.b = k - w;
                    if (pidx >= n)
                        r.e = 99;		// out of values--invalid code
                    else if (p[pidx] < s) {
                        r.e = (p[pidx] < 256 ? 16 : 15); // 256 is end-of-block code
                        r.n = p[pidx++];	// simple code is just the value
                    } else {
                        r.e = e[p[pidx] - s];	// non-simple--look up in lists
                        r.n = d[p[pidx++] - s];
                    }

                    // fill code-like entries with r //
                    f = 1 << (k - w);
                    for (j = i >> w; j < z; j += f) {
                        q[j].e = r.e;
                        q[j].b = r.b;
                        q[j].n = r.n;
                        q[j].t = r.t;
                    }

                    // backwards increment the k-bit code i
                    for (j = 1 << (k - 1); (i & j) != 0; j >>= 1)
                        i ^= j;
                    i ^= j;

                    // backup over finished tables
                    while ((i & ((1 << w) - 1)) != x[h]) {
                        w -= lx[h];		// don't need to update q
                        h--;
                    }
                }
            }

            /* return actual size of base table */
            this.m = lx[1];

            /* Return true (1) if we were given an incomplete table */
            this.status = ((y != 0 && g != 1) ? 1 : 0);
        }
        /* end of constructor */
    }


    /* routines (inflate) */

    function zip_GET_BYTE() {
        if (zip_inflate_data.length == zip_inflate_pos)
            return -1;
        return zip_inflate_data.charCodeAt(zip_inflate_pos++) & 0xff;
    }

    function zip_NEEDBITS(n) {
        while (zip_bit_len < n) {
            zip_bit_buf |= zip_GET_BYTE() << zip_bit_len;
            zip_bit_len += 8;
        }
    }

    function zip_GETBITS(n) {
        return zip_bit_buf & zip_MASK_BITS[n];
    }

    function zip_DUMPBITS(n) {
        zip_bit_buf >>= n;
        zip_bit_len -= n;
    }

    function zip_inflate_codes(buff, off, size) {
        /* inflate (decompress) the codes in a deflated (compressed) block.
         Return an error code or zero if it all goes ok. */
        var e;		// table entry flag/number of extra bits
        var t;		// (zip_HuftNode) pointer to table entry
        var n;

        if (size == 0)
            return 0;

        // inflate the coded data
        n = 0;
        for (; ;) {			// do until end of block
            zip_NEEDBITS(zip_bl);
            t = zip_tl.list[zip_GETBITS(zip_bl)];
            e = t.e;
            while (e > 16) {
                if (e == 99)
                    return -1;
                zip_DUMPBITS(t.b);
                e -= 16;
                zip_NEEDBITS(e);
                t = t.t[zip_GETBITS(e)];
                e = t.e;
            }
            zip_DUMPBITS(t.b);

            if (e == 16) {		// then it's a literal
                zip_wp &= zip_WSIZE - 1;
                buff[off + n++] = zip_slide[zip_wp++] = t.n;
                if (n == size)
                    return size;
                continue;
            }

            // exit if end of block
            if (e == 15)
                break;

            // it's an EOB or a length

            // get length of block to copy
            zip_NEEDBITS(e);
            zip_copy_leng = t.n + zip_GETBITS(e);
            zip_DUMPBITS(e);

            // decode distance of block to copy
            zip_NEEDBITS(zip_bd);
            t = zip_td.list[zip_GETBITS(zip_bd)];
            e = t.e;

            while (e > 16) {
                if (e == 99)
                    return -1;
                zip_DUMPBITS(t.b);
                e -= 16;
                zip_NEEDBITS(e);
                t = t.t[zip_GETBITS(e)];
                e = t.e;
            }
            zip_DUMPBITS(t.b);
            zip_NEEDBITS(e);
            zip_copy_dist = zip_wp - t.n - zip_GETBITS(e);
            zip_DUMPBITS(e);

            // do the copy
            while (zip_copy_leng > 0 && n < size) {
                zip_copy_leng--;
                zip_copy_dist &= zip_WSIZE - 1;
                zip_wp &= zip_WSIZE - 1;
                buff[off + n++] = zip_slide[zip_wp++]
                    = zip_slide[zip_copy_dist++];
            }

            if (n == size)
                return size;
        }

        zip_method = -1; // done
        return n;
    }

    function zip_inflate_stored(buff, off, size) {
        /* "decompress" an inflated type 0 (stored) block. */
        var n;

        // go to byte boundary
        n = zip_bit_len & 7;
        zip_DUMPBITS(n);

        // get the length and its complement
        zip_NEEDBITS(16);
        n = zip_GETBITS(16);
        zip_DUMPBITS(16);
        zip_NEEDBITS(16);
        if (n != ((~zip_bit_buf) & 0xffff))
            return -1;			// error in compressed data
        zip_DUMPBITS(16);

        // read and output the compressed data
        zip_copy_leng = n;

        n = 0;
        while (zip_copy_leng > 0 && n < size) {
            zip_copy_leng--;
            zip_wp &= zip_WSIZE - 1;
            zip_NEEDBITS(8);
            buff[off + n++] = zip_slide[zip_wp++] =
                zip_GETBITS(8);
            zip_DUMPBITS(8);
        }

        if (zip_copy_leng == 0)
            zip_method = -1; // done
        return n;
    }

    function zip_inflate_fixed(buff, off, size) {
        /* decompress an inflated type 1 (fixed Huffman codes) block.  We should
         either replace this with a custom decoder, or at least precompute the
         Huffman tables. */

        // if first time, set up tables for fixed blocks
        if (zip_fixed_tl == null) {
            var i;			// temporary variable
            var l = new Array(288);	// length list for huft_build
            var h;	// zip_HuftBuild

            // literal table
            for (i = 0; i < 144; i++)
                l[i] = 8;
            for (; i < 256; i++)
                l[i] = 9;
            for (; i < 280; i++)
                l[i] = 7;
            for (; i < 288; i++)	// make a complete, but wrong code set
                l[i] = 8;
            zip_fixed_bl = 7;

            h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext,
                zip_fixed_bl);
            if (h.status != 0) {
                alert("HufBuild error: " + h.status);
                return -1;
            }
            zip_fixed_tl = h.root;
            zip_fixed_bl = h.m;

            // distance table
            for (i = 0; i < 30; i++)	// make an incomplete code set
                l[i] = 5;
            zip_fixed_bd = 5;

            h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext, zip_fixed_bd);
            if (h.status > 1) {
                zip_fixed_tl = null;
                alert("HufBuild error: " + h.status);
                return -1;
            }
            zip_fixed_td = h.root;
            zip_fixed_bd = h.m;
        }

        zip_tl = zip_fixed_tl;
        zip_td = zip_fixed_td;
        zip_bl = zip_fixed_bl;
        zip_bd = zip_fixed_bd;
        return zip_inflate_codes(buff, off, size);
    }

    function zip_inflate_dynamic(buff, off, size) {
        // decompress an inflated type 2 (dynamic Huffman codes) block.
        var i;		// temporary variables
        var j;
        var l;		// last length
        var n;		// number of lengths to get
        var t;		// (zip_HuftNode) literal/length code table
        var nb;		// number of bit length codes
        var nl;		// number of literal/length codes
        var nd;		// number of distance codes
        var ll = new Array(286 + 30); // literal/length and distance code lengths
        var h;		// (zip_HuftBuild)

        for (i = 0; i < ll.length; i++)
            ll[i] = 0;

        // read in table lengths
        zip_NEEDBITS(5);
        nl = 257 + zip_GETBITS(5);	// number of literal/length codes
        zip_DUMPBITS(5);
        zip_NEEDBITS(5);
        nd = 1 + zip_GETBITS(5);	// number of distance codes
        zip_DUMPBITS(5);
        zip_NEEDBITS(4);
        nb = 4 + zip_GETBITS(4);	// number of bit length codes
        zip_DUMPBITS(4);
        if (nl > 286 || nd > 30)
            return -1;		// bad lengths

        // read in bit-length-code lengths
        for (j = 0; j < nb; j++) {
            zip_NEEDBITS(3);
            ll[zip_border[j]] = zip_GETBITS(3);
            zip_DUMPBITS(3);
        }
        for (; j < 19; j++)
            ll[zip_border[j]] = 0;

        // build decoding table for trees--single level, 7 bit lookup
        zip_bl = 7;
        h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl);
        if (h.status != 0)
            return -1;	// incomplete code set

        zip_tl = h.root;
        zip_bl = h.m;

        // read in literal and distance code lengths
        n = nl + nd;
        i = l = 0;
        while (i < n) {
            zip_NEEDBITS(zip_bl);
            t = zip_tl.list[zip_GETBITS(zip_bl)];
            j = t.b;
            zip_DUMPBITS(j);
            j = t.n;
            if (j < 16)		// length of code in bits (0..15)
                ll[i++] = l = j;	// save last length in l
            else if (j == 16) {	// repeat last length 3 to 6 times
                zip_NEEDBITS(2);
                j = 3 + zip_GETBITS(2);
                zip_DUMPBITS(2);
                if (i + j > n)
                    return -1;
                while (j-- > 0)
                    ll[i++] = l;
            } else if (j == 17) {	// 3 to 10 zero length codes
                zip_NEEDBITS(3);
                j = 3 + zip_GETBITS(3);
                zip_DUMPBITS(3);
                if (i + j > n)
                    return -1;
                while (j-- > 0)
                    ll[i++] = 0;
                l = 0;
            } else {		// j == 18: 11 to 138 zero length codes
                zip_NEEDBITS(7);
                j = 11 + zip_GETBITS(7);
                zip_DUMPBITS(7);
                if (i + j > n)
                    return -1;
                while (j-- > 0)
                    ll[i++] = 0;
                l = 0;
            }
        }

        // build the decoding tables for literal/length and distance codes
        zip_bl = zip_lbits;
        h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl);
        if (zip_bl == 0)	// no literals or lengths
            h.status = 1;
        if (h.status != 0) {
            if (h.status == 1)
                ;// **incomplete literal tree**
            return -1;		// incomplete code set
        }
        zip_tl = h.root;
        zip_bl = h.m;

        for (i = 0; i < nd; i++)
            ll[i] = ll[i + nl];
        zip_bd = zip_dbits;
        h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd);
        zip_td = h.root;
        zip_bd = h.m;

        if (zip_bd == 0 && nl > 257) {   // lengths but no distances
            // **incomplete distance tree**
            return -1;
        }

        if (h.status == 1) {
            ;// **incomplete distance tree**
        }
        if (h.status != 0)
            return -1;

        // decompress until an end-of-block code
        return zip_inflate_codes(buff, off, size);
    }

    function zip_inflate_start() {
        var i;

        if (zip_slide == null)
            zip_slide = new Array(2 * zip_WSIZE);
        zip_wp = 0;
        zip_bit_buf = 0;
        zip_bit_len = 0;
        zip_method = -1;
        zip_eof = false;
        zip_copy_leng = zip_copy_dist = 0;
        zip_tl = null;
    }

    function zip_inflate_internal(buff, off, size) {
        // decompress an inflated entry
        var n, i;

        n = 0;
        while (n < size) {
            if (zip_eof && zip_method == -1)
                return n;

            if (zip_copy_leng > 0) {
                if (zip_method != zip_STORED_BLOCK) {
                    // STATIC_TREES or DYN_TREES
                    while (zip_copy_leng > 0 && n < size) {
                        zip_copy_leng--;
                        zip_copy_dist &= zip_WSIZE - 1;
                        zip_wp &= zip_WSIZE - 1;
                        buff[off + n++] = zip_slide[zip_wp++] =
                            zip_slide[zip_copy_dist++];
                    }
                } else {
                    while (zip_copy_leng > 0 && n < size) {
                        zip_copy_leng--;
                        zip_wp &= zip_WSIZE - 1;
                        zip_NEEDBITS(8);
                        buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
                        zip_DUMPBITS(8);
                    }
                    if (zip_copy_leng == 0)
                        zip_method = -1; // done
                }
                if (n == size)
                    return n;
            }

            if (zip_method == -1) {
                if (zip_eof)
                    break;

                // read in last block bit
                zip_NEEDBITS(1);
                if (zip_GETBITS(1) != 0)
                    zip_eof = true;
                zip_DUMPBITS(1);

                // read in block type
                zip_NEEDBITS(2);
                zip_method = zip_GETBITS(2);
                zip_DUMPBITS(2);
                zip_tl = null;
                zip_copy_leng = 0;
            }

            switch (zip_method) {
                case 0: // zip_STORED_BLOCK
                    i = zip_inflate_stored(buff, off + n, size - n);
                    break;

                case 1: // zip_STATIC_TREES
                    if (zip_tl != null)
                        i = zip_inflate_codes(buff, off + n, size - n);
                    else
                        i = zip_inflate_fixed(buff, off + n, size - n);
                    break;

                case 2: // zip_DYN_TREES
                    if (zip_tl != null)
                        i = zip_inflate_codes(buff, off + n, size - n);
                    else
                        i = zip_inflate_dynamic(buff, off + n, size - n);
                    break;

                default: // error
                    i = -1;
                    break;
            }

            if (i == -1) {
                if (zip_eof)
                    return 0;
                return -1;
            }
            n += i;
        }
        return n;
    }

    ZIP.plugin.inflate = function(data) {
        var out, buff,i, j;

        zip_inflate_start();
        zip_inflate_data = data;
        zip_inflate_pos = 0;

        buff = new Array(1024);
        out = "";
        while ((i = zip_inflate_internal(buff, 0, buff.length)) > 0) {
            for (j = 0; j < i; ++j)
                out += String.fromCharCode(buff[j]);
        }
        zip_inflate_data = null; // G.C.

        return out;
    };
})(this.ZIP);